import utils.csv.CsvUtils;
import utils.json.JsonUtils;
import utils.xml.XmlUtils;
import utils.yaml.YamlUtils;

import javax.swing.*;
import java.awt.*;
import java.awt.datatransfer.Clipboard;
import java.awt.datatransfer.StringSelection;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import java.io.*;


/**
 * GUI界面运行类
 */
public class GUI {

    //文件类型选择下拉框和之后对于的转换类型下拉框
    private static JComboBox<String> ComboBox = new JComboBox<>();
    private static JComboBox<String> convertComboBox = new JComboBox<>();

    private static Boolean flag = false;

    //打开文件的类型后缀
//    private static String fileType = "";

//    private static String filePath = "";

    //监听文件打开状态
    private static boolean fileOpened = false;

    //存储文本框中内容的临时中间文件
    private static String temporary_file = "src\\main\\resources\\newFile.txt";

    private static JTextArea textArea;
    private static JTextArea textArea_new;

    /**
     * GUI界面运行类
     * @param args
     */

    public static void main(String[] args) {

        JFrame frame = new JFrame("GUI应用");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        JPanel panel = new JPanel(new GridBagLayout());

        // 创建文本区域
        textArea = new JTextArea();
        textArea.setText("");
        textArea_new = new JTextArea();
        textArea_new.setText("");
        textArea_new.setEditable(false);

        // 创建字体对象
        Font font = new Font("宋体", Font.PLAIN, 15);
        Font font_new = new Font("宋体", Font.PLAIN, 15);
        // 设置字体样式
        textArea.setFont(font);
        textArea_new.setFont(font_new);


        // 创建滚动面板，包装文本区域
        JScrollPane scrollPane = new JScrollPane(textArea);
        JScrollPane scrollPane_new = new JScrollPane(textArea_new);


        // 创建按钮

        JButton leftButtonCopy = new JButton("复制");
        JButton leftButtonClear = new JButton("清除");
        JButton leftButtonFormat = new JButton("格式化");
        JButton leftButtonCompress = new JButton("压缩");
        JButton leftButtonVaild = new JButton("验证");

        JButton button = new JButton("");
        ImageIcon icon = new ImageIcon("src\\main\\resources\\print.png");
        // 调整图像的尺寸
        Image image = icon.getImage();
        Image scaledImage = image.getScaledInstance(40, 30, Image.SCALE_SMOOTH);

        // 创建具有调整后尺寸的新ImageIcon对象
        ImageIcon scaledIcon = new ImageIcon(scaledImage);

        button.setIcon(scaledIcon);


        JLabel label_file = new JLabel("文件选择");
        JLabel label_type = new JLabel("转换类型");
        // 创建下拉框
//        JComboBox<String> comboBox = new JComboBox<>();
        ComboBox.addItem("json");
        ComboBox.addItem("csv");
        ComboBox.addItem("xml");
        ComboBox.addItem("yaml");


        convertComboBox.addItem("json2csv");
        convertComboBox.addItem("json2xml");
        convertComboBox.addItem("json2yaml");


        // 设置组件大小
//        label_file.setPreferredSize(new Dimension(80,30));
        ComboBox.setPreferredSize(new Dimension(80, 30));
        convertComboBox.setPreferredSize(new Dimension(80, 30));
        button.setPreferredSize(new Dimension(40, 30));
        JButton rightButtonCopy = new JButton("复制");
        JButton rightButtonClear = new JButton("清除");

// 创建面板用于容纳按钮
        JPanel buttonPanelLeft = new JPanel();
        buttonPanelLeft.add(leftButtonFormat);
        buttonPanelLeft.add(leftButtonCompress);
        buttonPanelLeft.add(leftButtonCopy);
        buttonPanelLeft.add(leftButtonClear);
        buttonPanelLeft.add(leftButtonVaild);


        // 创建左侧面板，用于容纳滚动面板和按钮面板
        JPanel leftPanel = new JPanel(new BorderLayout());
        leftPanel.add(buttonPanelLeft, BorderLayout.NORTH);
        leftPanel.add(scrollPane, BorderLayout.CENTER);


        /*
如果你想让中间部分窄一些，可以使用布局管理器中的权重（weight）属性来调整组件的大小分配。
在这种情况下，你可以将中间面板的权重设置为较小的值，让两侧的滚动面板占据更多的空间。

Swing组件只能在一个容器中使用一次
 */

//         设置左侧滚动面板的权重
        GridBagConstraints gbcScrollPaneLeft = new GridBagConstraints();
        gbcScrollPaneLeft.gridx = 0;
        gbcScrollPaneLeft.gridy = 0;
        //设置组件宽度和长度
        gbcScrollPaneLeft.weightx = 1.0;
        gbcScrollPaneLeft.weighty = 1.0;
        //fill属性设置为GridBagConstraints.BOTH，组件将在水平和垂直方向上填充其单元格，以充分利用可用的空间。
        gbcScrollPaneLeft.fill = GridBagConstraints.BOTH;
//        panel.add(buttonPanel, gbcScrollPaneLeft);
//        panel.add(scrollPane,gbcScrollPaneLeft);
        panel.add(leftPanel, gbcScrollPaneLeft);
//


        // 创建中间面板

        JPanel middlePanel = new JPanel();
        //BoxLayout布局管理器。BoxLayout允许您指定排列方向和对齐方式。设置上下排列
        middlePanel.setLayout(new BoxLayout(middlePanel, BoxLayout.Y_AXIS));
        middlePanel.add(label_file);

        // 添加垂直间隔
        int verticalGap = 15; // 指定间隔大小
        middlePanel.add(Box.createVerticalStrut(verticalGap));

        middlePanel.add(ComboBox);

        middlePanel.add(Box.createVerticalStrut(verticalGap));
        middlePanel.add(label_type);
        middlePanel.add(Box.createVerticalStrut(verticalGap));
        middlePanel.add(convertComboBox);
        middlePanel.add(Box.createVerticalStrut(verticalGap));
        middlePanel.add(button);


        // 设置中间面板的权重

        GridBagConstraints gbcMiddle = new GridBagConstraints();
        gbcMiddle.gridx = 1;
        gbcMiddle.gridy = 0;
        //这个属性用于指定组件在网格布局中占据的列数。
        //默认情况下，gridwidth的值为1，表示组件只占据一个单元格。但是，通过将gridwidth设置为大于1的值，可以让组件跨越多个列。
        // gbc3.gridwidth = 2;
        gbcMiddle.weightx = 0.8;
        gbcMiddle.weighty = 1.0;
        //设置对齐方式，居中
        gbcMiddle.anchor = GridBagConstraints.CENTER;
        panel.add(middlePanel, gbcMiddle);


        //在Swing中，一个组件只能被添加到一个容器中。
        JPanel rightButtonPanel = new JPanel();
        rightButtonPanel.add(rightButtonCopy);
        rightButtonPanel.add(rightButtonClear);
        // 创建右侧面板，用于容纳右侧滚动面板和右侧按钮面板
        JPanel rightPanel = new JPanel(new BorderLayout());
        rightPanel.add(scrollPane_new, BorderLayout.CENTER);
        rightPanel.add(rightButtonPanel, BorderLayout.NORTH);

        button.setVisible(true);
        // 刷新界面以确保按钮的可见性被更新
        button.revalidate();
        button.repaint();

        // 设置右侧滚动面板的权重
        GridBagConstraints gbcScrollPaneRight = new GridBagConstraints();
        gbcScrollPaneRight.gridx = 2;
        gbcScrollPaneRight.gridy = 0;
        gbcScrollPaneRight.weightx = 1.0;
        gbcScrollPaneRight.weighty = 1.0;
        gbcScrollPaneRight.fill = GridBagConstraints.BOTH;
//        panel.add(scrollPane_new, gbcScrollPaneRight);
        panel.add(rightPanel, gbcScrollPaneRight);


        frame.add(panel);


        // 创建菜单栏
        JMenuBar menuBar = new JMenuBar();

        // 创建菜单
        JMenu fileMenu_json = new JMenu("文件");

        // 创建菜单项
        JMenuItem openMenuItem = new JMenuItem("打开");
        JMenuItem saveMenuItem = new JMenuItem("保存");

        // 添加菜单项到菜单
        fileMenu_json.add(openMenuItem);
        fileMenu_json.add(saveMenuItem);

        // 将菜单添加到菜单栏
        menuBar.add(fileMenu_json);

        // 将菜单栏设置为主窗口的菜单栏
        frame.setJMenuBar(menuBar);


        //设置Windows外观：
        try {
            UIManager.setLookAndFeel("com.sun.java.swing.plaf.windows.WindowsLookAndFeel");
        } catch (Exception ex) {
            ex.printStackTrace();
        }


        // 获取屏幕尺寸
        GraphicsDevice gd = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice();
        int screenWidth = gd.getDisplayMode().getWidth();
        int screenHeight = gd.getDisplayMode().getHeight();

        // 设置 JFrame 的大小为全屏尺寸
        frame.setSize(screenWidth, screenHeight);
//        frame.setSize(800, 600);
        frame.setVisible(true);


        // 为文件选择下拉框添加项目选中的事件监听器
        ComboBox.addItemListener(new ItemListener() {
            @Override
            public void itemStateChanged(ItemEvent e) {
                String selectedFileType = "";
                if (e.getStateChange() == ItemEvent.SELECTED) {
                    selectedFileType = ComboBox.getSelectedItem().toString();
                    updateConvertComboBoxOptions(selectedFileType);
                }


            }

        });


        // 为菜单项添加事件监听器
        openMenuItem.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                // JFileChooser 对象，并用于显示一个文件选择对话框
                JFileChooser fileChooser = new JFileChooser();
                //showOpenDialog 方法将对话框显示在指定的 frame（窗口）上，并返回用户的选择结果。
                // 返回值是一个整数，表示用户的选择结果，可以通过一些预定义的常量来解释结果，如：
                //JFileChooser.APPROVE_OPTION：表示用户选择了一个文件并点击了"打开"按钮。
                //JFileChooser.CANCEL_OPTION：表示用户点击了"取消"按钮或关闭了对话框。
                //JFileChooser.ERROR_OPTION：表示发生了错误或对话框被关闭。
                int result = fileChooser.showOpenDialog(frame);
                if (result == JFileChooser.APPROVE_OPTION) {
                    fileOpened = true;
                    File selectedFile = fileChooser.getSelectedFile();
//                    filePath = selectedFile.getAbsolutePath();
//                    System.out.println("Selected file path: " + filePath);

//                    fileType = getFileType(selectedFile);
//                    System.out.println("Opened file type: " + fileType);
                    try (BufferedReader reader = new BufferedReader(new FileReader(selectedFile))) {
                        StringBuilder content = new StringBuilder();
                        String line;
                        while ((line = reader.readLine()) != null) {
//                            换行符在读取时被视为普通字符，而不会自动转换为实际的换行。
                            content.append(line);
                            content.append("\n");
                        }
                        textArea.setText(content.toString());
                    } catch (IOException ex) {
                        ex.printStackTrace();
                    }
                }
            }
        });

        saveMenuItem.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                JFileChooser fileChooser = new JFileChooser();
                int result = fileChooser.showSaveDialog(frame);
                if (result == JFileChooser.APPROVE_OPTION) {
                    File selectedFile = fileChooser.getSelectedFile();
                    try (FileWriter writer = new FileWriter(selectedFile)) {
                        String content = textArea_new.getText();
                        writer.write(content);
//                        System.out.println(content);
                        //保存，并显示保存成功
                        JOptionPane.showMessageDialog(frame, "文件保存成功！");
//                        String content = "Sample content to be saved.";
//                        writer.write(content);
//                        System.out.println("File saved successfully.");
                    } catch (IOException ex) {
                        ex.printStackTrace();
                    }
                }
            }
        });

        //转换按钮监听
        button.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                // 获取下拉框的选中项
                String selectedAlgorithm = (String) convertComboBox.getSelectedItem();
//                System.out.println("Selected algorithm: " + selectedAlgorithm);
                String selectedAlgorithmfile = (String) ComboBox.getSelectedItem();

                //在执行转换前先验证文件有效性
                if (selectedAlgorithmfile.equals("json") && !textArea.getText().isEmpty()) {
                    textWork();
                    flag = JsonUtils.jsonValidator(temporary_file);
                    deleteFile(temporary_file);
                } else if (selectedAlgorithmfile.equals("csv") && !textArea.getText().isEmpty()) {
                    textWork();
                    flag = CsvUtils.csvValidator(temporary_file, ",");
                    deleteFile(temporary_file);
                } else if (selectedAlgorithmfile.equals("xml") && !textArea.getText().isEmpty()) {
                    textWork();
                    flag = XmlUtils.xmlValidator(temporary_file);
                    deleteFile(temporary_file);
                } else if (selectedAlgorithmfile.equals("yaml") && !textArea.getText().isEmpty()) {
                    textWork();
                    flag = YamlUtils.yamlValidator(temporary_file);
                    deleteFile(temporary_file);
                }

                if (!textArea.getText().isEmpty() && !flag) {
                    JOptionPane.showMessageDialog(frame, "格式错误", "这是一个验证弹窗", JOptionPane.INFORMATION_MESSAGE);
                }

                try {

                    // 根据选中的算法执行相应的处理逻辑
                    if (selectedAlgorithm.equals("json2csv")) {
                        // 执行 json2csv 的处理逻辑
                        if (!textArea.getText().isEmpty() && flag) {
                            //新建文件，并把文本框中内容写入文件
                            textWork();
                            textArea_new.setText(JsonUtils.json2Csv(temporary_file, ","));
                            deleteFile(temporary_file);
                        }
                    } else if (selectedAlgorithm.equals("json2xml")) {
                        // 执行 json2xml 的处理逻辑
                        if (!textArea.getText().isEmpty() && flag) {
                            textWork();
                            textArea_new.setText(JsonUtils.json2Xml(temporary_file, "root", "\t"));
                            deleteFile(temporary_file);
                        }
                    } else if (selectedAlgorithm.equals("json2yaml")) {
                        if (!textArea.getText().isEmpty() && flag) {
                            textWork();
                            textArea_new.setText(JsonUtils.json2Yaml(temporary_file));
                            deleteFile(temporary_file);
                        }

                    } else if (selectedAlgorithm.equals("csv2json")) {
                        // 执行 csv2json 的处理逻辑
                        if (!textArea.getText().isEmpty() && flag) {
                            textWork();
                            textArea_new.setText(CsvUtils.csv2Json(temporary_file));
                            deleteFile(temporary_file);
                        }
                    } else if (selectedAlgorithm.equals("csv2xml")) {
                        // 执行 csv2xml 的处理逻辑
                        if (!textArea.getText().isEmpty() && flag) {
                            textWork();
                            textArea_new.setText(CsvUtils.csv2Xml(temporary_file));
                            deleteFile(temporary_file);
                        }
                    } else if (selectedAlgorithm.equals("csv2yaml")) {
                        if (!textArea.getText().isEmpty() && flag) {
                            textWork();
                            textArea_new.setText(CsvUtils.csv2Yaml(temporary_file));
                            deleteFile(temporary_file);
                        }
                    } else if (selectedAlgorithm.equals("xml2json")) {
                        // 执行 xml2json 的处理逻辑
                        if (!textArea.getText().isEmpty() && flag) {
                            textWork();
                            textArea_new.setText(XmlUtils.xml2Json(temporary_file));
                            deleteFile(temporary_file);
                        }
                    } else if (selectedAlgorithm.equals("xml2csv")) {
                        // 执行 xml2csv 的处理逻辑
                        if (!textArea.getText().isEmpty() && flag) {
                            textWork();
                            textArea_new.setText(XmlUtils.xml2Csv(temporary_file));
                            deleteFile(temporary_file);
                        }
                    } else if (selectedAlgorithm.equals("xml2yaml")) {
                        if (!textArea.getText().isEmpty() && flag) {
                            textWork();
                            textArea_new.setText(XmlUtils.xml2Yaml(temporary_file));
                            deleteFile(temporary_file);
                        }
                    } else if (selectedAlgorithm.equals("yaml2json")) {
                        if (!textArea.getText().isEmpty() && flag) {
                            textWork();
                            textArea_new.setText(YamlUtils.yaml2Json(temporary_file));
                            deleteFile(temporary_file);
                        }
                    } else if (selectedAlgorithm.equals("yaml2xml")) {
                        if (!textArea.getText().isEmpty() && flag) {
                            textWork();
                            textArea_new.setText(YamlUtils.yaml2Xml(temporary_file, "root"));
                            deleteFile(temporary_file);
                        }
                    } else if (selectedAlgorithm.equals("yaml2csv")) {
                        if (!textArea.getText().isEmpty() && flag) {
                            textWork();
                            textArea_new.setText(YamlUtils.yaml2Csv(temporary_file));
                            deleteFile(temporary_file);
                        }
                    }

                    // 其他处理逻辑...
                } catch (Exception exception) {
                    JOptionPane.showMessageDialog(frame, "格式错误", "这是一个验证弹窗", JOptionPane.INFORMATION_MESSAGE);
//                    System.out.println("出现异常");
                }
            }
        });

        //格式化监听
        leftButtonFormat.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                // 在此处添加处理按钮点击事件的代码
                // 当 leftButtonFormat 被点击时，将执行此处的代码
                // 可以在这里编写格式化文本的逻辑
                String selectedAlgorithm = (String) ComboBox.getSelectedItem();
//                System.out.println("Selected algorithm: " + selectedAlgorithm);
                try {
                    if (selectedAlgorithm.equals("json") && !textArea.getText().isEmpty()) {
                        textWork();
                        textArea.setText(JsonUtils.jsonFormatter(temporary_file));
                        deleteFile(temporary_file);
                    } else if (selectedAlgorithm.equals("csv") && !textArea.getText().isEmpty()) {
                        textWork();
                        textArea.setText(CsvUtils.csvFormatter(temporary_file));
                        deleteFile(temporary_file);
                    } else if (selectedAlgorithm.equals("xml") && !textArea.getText().isEmpty()) {
                        textWork();
                        textArea.setText(XmlUtils.xmlFormatter(temporary_file));
                        deleteFile(temporary_file);
                    } else if (selectedAlgorithm.equals("yaml") && !textArea.getText().isEmpty()) {
                        textWork();
                        textArea.setText(YamlUtils.yamlFormatter(temporary_file));
                        deleteFile(temporary_file);
                    }
                } catch (Exception ex) {
//                    ex.printStackTrace();
                    JOptionPane.showMessageDialog(frame, "文件不符合要求", "这是一个警告弹窗", JOptionPane.WARNING_MESSAGE);
                }

            }
        });

        //压缩按钮监听
        leftButtonCompress.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                // 在此处添加处理按钮点击事件的代码
                // 当 leftButtonFormat 被点击时，将执行此处的代码
                // 可以在这里编写格式化文本的逻辑
                String selectedAlgorithm = (String) ComboBox.getSelectedItem();
//                System.out.println("Selected Compress algorithm: " + selectedAlgorithm);
                if (selectedAlgorithm.equals("json") && !textArea.getText().isEmpty()) {
                    textWork();
                    textArea.setText(JsonUtils.jsonCompress(temporary_file));
                    deleteFile(temporary_file);
                } else if (selectedAlgorithm.equals("xml") && !textArea.getText().isEmpty()) {
                    textWork();
                    textArea.setText(XmlUtils.convertFromXml(temporary_file));
                    deleteFile(temporary_file);
                }
            }
        });

        //复制按钮监听
        leftButtonCopy.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                String text = textArea.getText();
                //StringSelection是Java中的一个类，用于封装文本字符串以进行剪贴板操作。
                // 它实现了Transferable接口，表示可以在不同应用程序之间传输的数据。
                StringSelection selection = new StringSelection(text);
                //获取系统剪贴板的实例
                Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
                //将文本内容设置到剪贴板上
                clipboard.setContents(selection, null);

            }
        });

        rightButtonCopy.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                String text = textArea_new.getText();
                //StringSelection是Java中的一个类，用于封装文本字符串以进行剪贴板操作。
                // 它实现了Transferable接口，表示可以在不同应用程序之间传输的数据。
                StringSelection selection = new StringSelection(text);
                //获取系统剪贴板的实例
                Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
                //将文本内容设置到剪贴板上
                clipboard.setContents(selection, null);

            }
        });

        //清除按钮监听
        leftButtonClear.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                textArea.setText("");
            }
        });
        rightButtonClear.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                textArea_new.setText("");
            }
        });


        //验证按钮监听
        leftButtonVaild.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                String selectedAlgorithm = (String) ComboBox.getSelectedItem();
                if (selectedAlgorithm.equals("json") && !textArea.getText().isEmpty()) {
                    textWork();
                    flag = JsonUtils.jsonValidator(temporary_file);
                    deleteFile(temporary_file);
                } else if (selectedAlgorithm.equals("csv") && !textArea.getText().isEmpty()) {
                    textWork();
                    flag = CsvUtils.csvValidator(temporary_file, ",");
                    deleteFile(temporary_file);
                } else if (selectedAlgorithm.equals("xml") && !textArea.getText().isEmpty()) {
                    textWork();
                    flag = XmlUtils.xmlValidator(temporary_file);
                    deleteFile(temporary_file);
                } else if (selectedAlgorithm.equals("yaml") && !textArea.getText().isEmpty()) {
                    textWork();
                    flag = YamlUtils.yamlValidator(temporary_file);
                    deleteFile(temporary_file);
                }
                if (flag) {
                    JOptionPane.showMessageDialog(frame, "格式正确", "这是一个验证弹窗", JOptionPane.INFORMATION_MESSAGE);
                } else if (!flag && !textArea.getText().isEmpty()) {
                    JOptionPane.showMessageDialog(frame, "文件格式错误", "这是一个验证弹窗", JOptionPane.INFORMATION_MESSAGE);
//                    System.out.println(flag);
                }

            }
        });


    }

    // 更新转换下拉框的选项
    private static void updateConvertComboBoxOptions(String selectedFileType) {
        DefaultComboBoxModel<String> convertComboBoxModel = new DefaultComboBoxModel<>();
        //获取convertComboBox的模型对象，并将其转换为DefaultComboBoxModel<String>类型。
        // 然后，使用removeAllElements()方法从模型中移除所有的元素，从而清空下拉项。
        DefaultComboBoxModel<String> model = (DefaultComboBoxModel<String>) convertComboBox.getModel();
        model.removeAllElements();
        if (selectedFileType.equals("json")) {
            convertComboBoxModel.addElement("json2csv");
            convertComboBoxModel.addElement("json2xml");
            convertComboBoxModel.addElement("json2yaml");
        } else if (selectedFileType.equals("csv")) {
            convertComboBoxModel.addElement("csv2json");
            convertComboBoxModel.addElement("csv2xml");
            convertComboBoxModel.addElement("csv2yaml");
        } else if (selectedFileType.equals("xml")) {
            convertComboBoxModel.addElement("xml2json");
            convertComboBoxModel.addElement("xml2csv");
            convertComboBoxModel.addElement("xml2yaml");
        } else if (selectedFileType.equals("yaml")) {
            convertComboBoxModel.addElement("yaml2json");
            convertComboBoxModel.addElement("yaml2xml");
            convertComboBoxModel.addElement("yaml2csv");
        }
        convertComboBox.setModel(convertComboBoxModel);

    }


    private static String getFileType(File file) {
        String fileName = file.getName();
        int dotIndex = fileName.lastIndexOf(".");
        if (dotIndex > 0 && dotIndex < fileName.length() - 1) {
            return fileName.substring(dotIndex + 1);
        }
        return "";
    }

    //创建文件
    private static void createFile(String filePath) {
        File file = new File(filePath);
        try {
            if (file.createNewFile()) {
//                System.out.println("File created successfully.");
            }
//            else {
//                System.out.println("File already exists.");
//            }
        } catch (IOException e) {
            System.out.println("An error occurred while creating the file: " + e.getMessage());
        }
    }

    //写入文件
    public static void writeToFile(String filePath, String content) {
        try (BufferedWriter writer = new BufferedWriter(new FileWriter(filePath))) {
            writer.write(content);
//            System.out.println("Content has been written to the file.");
        } catch (IOException e) {
//            System.out.println("An error occurred while writing to the file: " + e.getMessage());
        }
    }

    //删除文件
    private static void deleteFile(String filePath) {
        File file = new File(filePath);
        if (file.exists()) {
            if (file.delete()) {
//                System.out.println("File has been deleted.");
            }
//            else {
//                System.out.println("Failed to delete the file.");
//            }
        } else {
            System.out.println("File does not exist.");
        }
    }

    private static void textWork() {
        createFile(temporary_file);
        writeToFile(temporary_file, textArea.getText());

    }

}
